home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / sun / misc / FpUtils.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  3.4 KB  |  308 lines
  1. package sun.misc;
  2.  
  3. public class FpUtils {
  4.    static double twoToTheDoubleScaleUp = powerOfTwoD(512);
  5.    static double twoToTheDoubleScaleDown = powerOfTwoD(-512);
  6.  
  7.    private FpUtils() {
  8.    }
  9.  
  10.    public static int getExponent(double var0) {
  11.       return (int)(((Double.doubleToRawLongBits(var0) & 9218868437227405312L) >> 52) - 1023L);
  12.    }
  13.  
  14.    public static int getExponent(float var0) {
  15.       return ((Float.floatToRawIntBits(var0) & 2139095040) >> 23) - 127;
  16.    }
  17.  
  18.    static double powerOfTwoD(int var0) {
  19.       assert var0 >= -1022 && var0 <= 1023;
  20.  
  21.       return Double.longBitsToDouble((long)var0 + 1023L << 52 & 9218868437227405312L);
  22.    }
  23.  
  24.    static float powerOfTwoF(int var0) {
  25.       assert var0 >= -126 && var0 <= 127;
  26.  
  27.       return Float.intBitsToFloat(var0 + 127 << 23 & 2139095040);
  28.    }
  29.  
  30.    public static double rawCopySign(double var0, double var2) {
  31.       return Double.longBitsToDouble(Double.doubleToRawLongBits(var2) & Long.MIN_VALUE | Double.doubleToRawLongBits(var0) & Long.MAX_VALUE);
  32.    }
  33.  
  34.    public static float rawCopySign(float var0, float var1) {
  35.       return Float.intBitsToFloat(Float.floatToRawIntBits(var1) & Integer.MIN_VALUE | Float.floatToRawIntBits(var0) & Integer.MAX_VALUE);
  36.    }
  37.  
  38.    public static boolean isFinite(double var0) {
  39.       return Math.abs(var0) <= Double.MAX_VALUE;
  40.    }
  41.  
  42.    public static boolean isFinite(float var0) {
  43.       return Math.abs(var0) <= Float.MAX_VALUE;
  44.    }
  45.  
  46.    public static boolean isInfinite(double var0) {
  47.       return Double.isInfinite(var0);
  48.    }
  49.  
  50.    public static boolean isInfinite(float var0) {
  51.       return Float.isInfinite(var0);
  52.    }
  53.  
  54.    public static boolean isNaN(double var0) {
  55.       return Double.isNaN(var0);
  56.    }
  57.  
  58.    public static boolean isNaN(float var0) {
  59.       return Float.isNaN(var0);
  60.    }
  61.  
  62.    public static boolean isUnordered(double var0, double var2) {
  63.       return isNaN(var0) || isNaN(var2);
  64.    }
  65.  
  66.    public static boolean isUnordered(float var0, float var1) {
  67.       return isNaN(var0) || isNaN(var1);
  68.    }
  69.  
  70.    public static int ilogb(double var0) {
  71.       int var2 = getExponent(var0);
  72.       switch (var2) {
  73.          case -1023:
  74.             if (var0 == (double)0.0F) {
  75.                return -268435456;
  76.             } else {
  77.                long var3 = Double.doubleToRawLongBits(var0);
  78.                var3 &= 4503599627370495L;
  79.  
  80.                assert var3 != 0L;
  81.  
  82.                while(var3 < 4503599627370496L) {
  83.                   var3 *= 2L;
  84.                   --var2;
  85.                }
  86.  
  87.                ++var2;
  88.                if ($assertionsDisabled || var2 >= -1074 && var2 < -1022) {
  89.                   return var2;
  90.                }
  91.  
  92.                throw new AssertionError();
  93.             }
  94.          case 1024:
  95.             if (isNaN(var0)) {
  96.                return 1073741824;
  97.             }
  98.  
  99.             return 268435456;
  100.          default:
  101.             assert var2 >= -1022 && var2 <= 1023;
  102.  
  103.             return var2;
  104.       }
  105.    }
  106.  
  107.    public static int ilogb(float var0) {
  108.       int var1 = getExponent(var0);
  109.       switch (var1) {
  110.          case -127:
  111.             if (var0 == 0.0F) {
  112.                return -268435456;
  113.             } else {
  114.                int var2 = Float.floatToRawIntBits(var0);
  115.                var2 &= 8388607;
  116.  
  117.                assert var2 != 0;
  118.  
  119.                while(var2 < 8388608) {
  120.                   var2 *= 2;
  121.                   --var1;
  122.                }
  123.  
  124.                ++var1;
  125.                if ($assertionsDisabled || var1 >= -149 && var1 < -126) {
  126.                   return var1;
  127.                }
  128.  
  129.                throw new AssertionError();
  130.             }
  131.          case 128:
  132.             if (isNaN(var0)) {
  133.                return 1073741824;
  134.             }
  135.  
  136.             return 268435456;
  137.          default:
  138.             assert var1 >= -126 && var1 <= 127;
  139.  
  140.             return var1;
  141.       }
  142.    }
  143.  
  144.    public static double scalb(double var0, int var2) {
  145.       int var4 = 0;
  146.       short var5 = 0;
  147.       double var6 = Double.NaN;
  148.       if (var2 < 0) {
  149.          var2 = Math.max(var2, -2099);
  150.          var5 = -512;
  151.          var6 = twoToTheDoubleScaleDown;
  152.       } else {
  153.          var2 = Math.min(var2, 2099);
  154.          var5 = 512;
  155.          var6 = twoToTheDoubleScaleUp;
  156.       }
  157.  
  158.       int var8 = var2 >> 8 >>> 23;
  159.       var4 = (var2 + var8 & 511) - var8;
  160.       var0 *= powerOfTwoD(var4);
  161.  
  162.       for(int var11 = var2 - var4; var11 != 0; var11 -= var5) {
  163.          var0 *= var6;
  164.       }
  165.  
  166.       return var0;
  167.    }
  168.  
  169.    public static float scalb(float var0, int var1) {
  170.       var1 = Math.max(Math.min(var1, 278), -278);
  171.       return (float)((double)var0 * powerOfTwoD(var1));
  172.    }
  173.  
  174.    public static double nextAfter(double var0, double var2) {
  175.       if (!isNaN(var0) && !isNaN(var2)) {
  176.          if (var0 == var2) {
  177.             return var2;
  178.          } else {
  179.             long var4 = Double.doubleToRawLongBits(var0 + (double)0.0F);
  180.             if (var2 > var0) {
  181.                var4 += var4 >= 0L ? 1L : -1L;
  182.             } else {
  183.                assert var2 < var0;
  184.  
  185.                if (var4 > 0L) {
  186.                   --var4;
  187.                } else if (var4 < 0L) {
  188.                   ++var4;
  189.                } else {
  190.                   var4 = -9223372036854775807L;
  191.                }
  192.             }
  193.  
  194.             return Double.longBitsToDouble(var4);
  195.          }
  196.       } else {
  197.          return var0 + var2;
  198.       }
  199.    }
  200.  
  201.    public static float nextAfter(float var0, double var1) {
  202.       if (!isNaN(var0) && !isNaN(var1)) {
  203.          if ((double)var0 == var1) {
  204.             return (float)var1;
  205.          } else {
  206.             int var3 = Float.floatToRawIntBits(var0 + 0.0F);
  207.             if (var1 > (double)var0) {
  208.                var3 += var3 >= 0 ? 1 : -1;
  209.             } else {
  210.                assert var1 < (double)var0;
  211.  
  212.                if (var3 > 0) {
  213.                   --var3;
  214.                } else if (var3 < 0) {
  215.                   ++var3;
  216.                } else {
  217.                   var3 = -2147483647;
  218.                }
  219.             }
  220.  
  221.             return Float.intBitsToFloat(var3);
  222.          }
  223.       } else {
  224.          return var0 + (float)var1;
  225.       }
  226.    }
  227.  
  228.    public static double nextUp(double var0) {
  229.       if (!isNaN(var0) && var0 != Double.POSITIVE_INFINITY) {
  230.          var0 += (double)0.0F;
  231.          return Double.longBitsToDouble(Double.doubleToRawLongBits(var0) + (var0 >= (double)0.0F ? 1L : -1L));
  232.       } else {
  233.          return var0;
  234.       }
  235.    }
  236.  
  237.    public static float nextUp(float var0) {
  238.       if (!isNaN(var0) && var0 != Float.POSITIVE_INFINITY) {
  239.          var0 += 0.0F;
  240.          return Float.intBitsToFloat(Float.floatToRawIntBits(var0) + (var0 >= 0.0F ? 1 : -1));
  241.       } else {
  242.          return var0;
  243.       }
  244.    }
  245.  
  246.    public static double nextDown(double var0) {
  247.       if (!isNaN(var0) && var0 != Double.NEGATIVE_INFINITY) {
  248.          return var0 == (double)0.0F ? -Double.MIN_VALUE : Double.longBitsToDouble(Double.doubleToRawLongBits(var0) + (var0 > (double)0.0F ? -1L : 1L));
  249.       } else {
  250.          return var0;
  251.       }
  252.    }
  253.  
  254.    public static double nextDown(float var0) {
  255.       if (!isNaN(var0) && var0 != Float.NEGATIVE_INFINITY) {
  256.          return var0 == 0.0F ? (double)-Float.MIN_VALUE : (double)Float.intBitsToFloat(Float.floatToRawIntBits(var0) + (var0 > 0.0F ? -1 : 1));
  257.       } else {
  258.          return (double)var0;
  259.       }
  260.    }
  261.  
  262.    public static double copySign(double var0, double var2) {
  263.       return rawCopySign(var0, isNaN(var2) ? (double)1.0F : var2);
  264.    }
  265.  
  266.    public static float copySign(float var0, float var1) {
  267.       return rawCopySign(var0, isNaN(var1) ? 1.0F : var1);
  268.    }
  269.  
  270.    public static double ulp(double var0) {
  271.       int var2 = getExponent(var0);
  272.       switch (var2) {
  273.          case -1023:
  274.             return Double.MIN_VALUE;
  275.          case 1024:
  276.             return Math.abs(var0);
  277.          default:
  278.             assert var2 <= 1023 && var2 >= -1022;
  279.  
  280.             var2 -= 52;
  281.             return var2 >= -1022 ? powerOfTwoD(var2) : Double.longBitsToDouble(1L << var2 - -1074);
  282.       }
  283.    }
  284.  
  285.    public static float ulp(float var0) {
  286.       int var1 = getExponent(var0);
  287.       switch (var1) {
  288.          case -127:
  289.             return Float.MIN_VALUE;
  290.          case 128:
  291.             return Math.abs(var0);
  292.          default:
  293.             assert var1 <= 127 && var1 >= -126;
  294.  
  295.             var1 -= 23;
  296.             return var1 >= -126 ? powerOfTwoF(var1) : Float.intBitsToFloat(1 << var1 - -149);
  297.       }
  298.    }
  299.  
  300.    public static double signum(double var0) {
  301.       return var0 != (double)0.0F && !isNaN(var0) ? copySign((double)1.0F, var0) : var0;
  302.    }
  303.  
  304.    public static float signum(float var0) {
  305.       return var0 != 0.0F && !isNaN(var0) ? copySign(1.0F, var0) : var0;
  306.    }
  307. }
  308.